"""
__build_back_M2M_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Mon Dec  3 16:39:39 2012
____________________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from MT_pre__Male_S import *
from MT_pre__MatchModel import *
from MT_pre__ApplyModel import *
from MT_pre__Male_T import *
from MT_pre__match_contains import *
from MT_pre__apply_contains import *
from MT_post__match_contains import *
from MT_post__MatchModel import *
from MT_post__apply_contains import *
from MT_post__backward_link import *
from MT_post__ApplyModel import *
from MT_post__Male_T import *
from MT_post__Male_S import *
from RHS import *
from LHS import *
from graph_MT_pre__Male_T import *
from graph_MT_post__match_contains import *
from graph_MT_pre__apply_contains import *
from graph_MT_pre__Male_S import *
from graph_LHS import *
from graph_MT_post__ApplyModel import *
from graph_MT_pre__match_contains import *
from graph_MT_pre__MatchModel import *
from graph_MT_pre__ApplyModel import *
from graph_MT_post__MatchModel import *
from graph_MT_post__apply_contains import *
from graph_MT_post__Male_S import *
from graph_RHS import *
from graph_MT_post__Male_T import *
from graph_MT_post__backward_link import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def build_back_M2M_MDL(self, rootNode, MT_pre__SimpleDSLTransRootNode=None, MT_post__SimpleDSLTransRootNode=None, MoTifRuleRootNode=None):

    # --- Generating attributes code for ASG MT_pre__SimpleDSLTrans ---
    if( MT_pre__SimpleDSLTransRootNode ): 
        # author
        MT_pre__SimpleDSLTransRootNode.author.setValue('Annonymous')

        # description
        MT_pre__SimpleDSLTransRootNode.description.setValue('\n')
        MT_pre__SimpleDSLTransRootNode.description.setHeight(15)

        # name
        MT_pre__SimpleDSLTransRootNode.name.setValue('')
        MT_pre__SimpleDSLTransRootNode.name.setNone()
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MT_post__SimpleDSLTrans ---
    if( MT_post__SimpleDSLTransRootNode ): 
        # author
        MT_post__SimpleDSLTransRootNode.author.setValue('Annonymous')

        # description
        MT_post__SimpleDSLTransRootNode.description.setValue('\n')
        MT_post__SimpleDSLTransRootNode.description.setHeight(15)

        # name
        MT_post__SimpleDSLTransRootNode.name.setValue('')
        MT_post__SimpleDSLTransRootNode.name.setNone()
    # --- ASG attributes over ---


    # --- Generating attributes code for ASG MoTifRule ---
    if( MoTifRuleRootNode ): 
        # author
        MoTifRuleRootNode.author.setValue('Annonymous')

        # description
        MoTifRuleRootNode.description.setValue('\n')
        MoTifRuleRootNode.description.setHeight(15)

        # name
        MoTifRuleRootNode.name.setValue('Build_back_M2M')
    # --- ASG attributes over ---


    self.obj28555=MT_pre__Male_S(self)
    self.obj28555.isGraphObjectVisual = True

    if(hasattr(self.obj28555, '_setHierarchicalLink')):
      self.obj28555._setHierarchicalLink(False)

    # MT_label__
    self.obj28555.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj28555.MT_pivotOut__.setValue('')
    self.obj28555.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28555.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28555.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj28555.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj28555.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj28555.MT_pivotIn__.setValue('')
    self.obj28555.MT_pivotIn__.setNone()

    self.obj28555.graphClass_= graph_MT_pre__Male_S
    if self.genGraphics:
       new_obj = graph_MT_pre__Male_S(810.0,339.0,self.obj28555)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28555.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28555)
    self.globalAndLocalPostcondition(self.obj28555, rootNode)
    self.obj28555.postAction( rootNode.CREATE )

    self.obj28557=MT_pre__MatchModel(self)
    self.obj28557.isGraphObjectVisual = True

    if(hasattr(self.obj28557, '_setHierarchicalLink')):
      self.obj28557._setHierarchicalLink(False)

    # MT_label__
    self.obj28557.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj28557.MT_pivotOut__.setValue('')
    self.obj28557.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28557.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28557.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj28557.MT_pivotIn__.setValue('')
    self.obj28557.MT_pivotIn__.setNone()

    self.obj28557.graphClass_= graph_MT_pre__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_pre__MatchModel(590.0,279.0,self.obj28557)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28557.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28557)
    self.globalAndLocalPostcondition(self.obj28557, rootNode)
    self.obj28557.postAction( rootNode.CREATE )

    self.obj28558=MT_pre__ApplyModel(self)
    self.obj28558.isGraphObjectVisual = True

    if(hasattr(self.obj28558, '_setHierarchicalLink')):
      self.obj28558._setHierarchicalLink(False)

    # MT_label__
    self.obj28558.MT_label__.setValue('2')

    # MT_pivotOut__
    self.obj28558.MT_pivotOut__.setValue('')
    self.obj28558.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28558.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28558.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj28558.MT_pivotIn__.setValue('')
    self.obj28558.MT_pivotIn__.setNone()

    self.obj28558.graphClass_= graph_MT_pre__ApplyModel
    if self.genGraphics:
       new_obj = graph_MT_pre__ApplyModel(590.0,419.0,self.obj28558)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28558.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28558)
    self.globalAndLocalPostcondition(self.obj28558, rootNode)
    self.obj28558.postAction( rootNode.CREATE )

    self.obj28559=MT_pre__Male_T(self)
    self.obj28559.isGraphObjectVisual = True

    if(hasattr(self.obj28559, '_setHierarchicalLink')):
      self.obj28559._setHierarchicalLink(False)

    # MT_label__
    self.obj28559.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj28559.MT_pivotOut__.setValue('')
    self.obj28559.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28559.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28559.MT_subtypeMatching__.config = 0

    # MT_pre__name
    self.obj28559.MT_pre__name.setValue('\n#===============================================================================\n# This code is executed when evaluating if a node shall be matched by this rule.\n# You can access the value of the current node\'s attribute value by: attr_value.\n# You can access any attribute x of this node by: this[\'x\'].\n# If the constraint relies on attribute values from other nodes,\n# use the LHS/NAC constraint instead.\n# The given constraint must evaluate to a boolean expression.\n#===============================================================================\n\nreturn True\n')
    self.obj28559.MT_pre__name.setHeight(15)

    # MT_pivotIn__
    self.obj28559.MT_pivotIn__.setValue('')
    self.obj28559.MT_pivotIn__.setNone()

    self.obj28559.graphClass_= graph_MT_pre__Male_T
    if self.genGraphics:
       new_obj = graph_MT_pre__Male_T(810.0,479.0,self.obj28559)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__Male_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28559.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28559)
    self.globalAndLocalPostcondition(self.obj28559, rootNode)
    self.obj28559.postAction( rootNode.CREATE )

    self.obj28561=MT_pre__match_contains(self)
    self.obj28561.isGraphObjectVisual = True

    if(hasattr(self.obj28561, '_setHierarchicalLink')):
      self.obj28561._setHierarchicalLink(False)

    # MT_label__
    self.obj28561.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj28561.MT_pivotOut__.setValue('')
    self.obj28561.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28561.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28561.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj28561.MT_pivotIn__.setValue('')
    self.obj28561.MT_pivotIn__.setNone()

    self.obj28561.graphClass_= graph_MT_pre__match_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__match_contains(771.0,350.0,self.obj28561)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj28561.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28561)
    self.globalAndLocalPostcondition(self.obj28561, rootNode)
    self.obj28561.postAction( rootNode.CREATE )

    self.obj28562=MT_pre__apply_contains(self)
    self.obj28562.isGraphObjectVisual = True

    if(hasattr(self.obj28562, '_setHierarchicalLink')):
      self.obj28562._setHierarchicalLink(False)

    # MT_label__
    self.obj28562.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj28562.MT_pivotOut__.setValue('')
    self.obj28562.MT_pivotOut__.setNone()

    # MT_subtypeMatching__
    self.obj28562.MT_subtypeMatching__.setValue(('True', 0))
    self.obj28562.MT_subtypeMatching__.config = 0

    # MT_pivotIn__
    self.obj28562.MT_pivotIn__.setValue('')
    self.obj28562.MT_pivotIn__.setNone()

    self.obj28562.graphClass_= graph_MT_pre__apply_contains
    if self.genGraphics:
       new_obj = graph_MT_pre__apply_contains(773.0,490.0,self.obj28562)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_pre__apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj28562.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28562)
    self.globalAndLocalPostcondition(self.obj28562, rootNode)
    self.obj28562.postAction( rootNode.CREATE )

    self.obj28564=MT_post__match_contains(self)
    self.obj28564.isGraphObjectVisual = True

    if(hasattr(self.obj28564, '_setHierarchicalLink')):
      self.obj28564._setHierarchicalLink(False)

    # MT_label__
    self.obj28564.MT_label__.setValue('5')

    # MT_pivotOut__
    self.obj28564.MT_pivotOut__.setValue('')
    self.obj28564.MT_pivotOut__.setNone()

    self.obj28564.graphClass_= graph_MT_post__match_contains
    if self.genGraphics:
       new_obj = graph_MT_post__match_contains(1292.5,350.0,self.obj28564)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj28564.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28564)
    self.globalAndLocalPostcondition(self.obj28564, rootNode)
    self.obj28564.postAction( rootNode.CREATE )

    self.obj28565=MT_post__MatchModel(self)
    self.obj28565.isGraphObjectVisual = True

    if(hasattr(self.obj28565, '_setHierarchicalLink')):
      self.obj28565._setHierarchicalLink(False)

    # MT_label__
    self.obj28565.MT_label__.setValue('1')

    # MT_pivotOut__
    self.obj28565.MT_pivotOut__.setValue('')
    self.obj28565.MT_pivotOut__.setNone()

    self.obj28565.graphClass_= graph_MT_post__MatchModel
    if self.genGraphics:
       new_obj = graph_MT_post__MatchModel(1110.0,279.0,self.obj28565)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28565.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28565)
    self.globalAndLocalPostcondition(self.obj28565, rootNode)
    self.obj28565.postAction( rootNode.CREATE )

    self.obj28566=MT_post__apply_contains(self)
    self.obj28566.isGraphObjectVisual = True

    if(hasattr(self.obj28566, '_setHierarchicalLink')):
      self.obj28566._setHierarchicalLink(False)

    # MT_label__
    self.obj28566.MT_label__.setValue('6')

    # MT_pivotOut__
    self.obj28566.MT_pivotOut__.setValue('')
    self.obj28566.MT_pivotOut__.setNone()

    self.obj28566.graphClass_= graph_MT_post__apply_contains
    if self.genGraphics:
       new_obj = graph_MT_post__apply_contains(1294.5,490.0,self.obj28566)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj28566.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28566)
    self.globalAndLocalPostcondition(self.obj28566, rootNode)
    self.obj28566.postAction( rootNode.CREATE )

    self.obj28567=MT_post__backward_link(self)
    self.obj28567.isGraphObjectVisual = True

    if(hasattr(self.obj28567, '_setHierarchicalLink')):
      self.obj28567._setHierarchicalLink(False)

    # MT_label__
    self.obj28567.MT_label__.setValue('7')

    # MT_pivotOut__
    self.obj28567.MT_pivotOut__.setValue('')
    self.obj28567.MT_pivotOut__.setNone()

    self.obj28567.graphClass_= graph_MT_post__backward_link
    if self.genGraphics:
       new_obj = graph_MT_post__backward_link(1391.0,450.0,self.obj28567)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__backward_link", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj28567.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28567)
    self.globalAndLocalPostcondition(self.obj28567, rootNode)
    self.obj28567.postAction( rootNode.CREATE )

    self.obj28568=MT_post__ApplyModel(self)
    self.obj28568.isGraphObjectVisual = True

    if(hasattr(self.obj28568, '_setHierarchicalLink')):
      self.obj28568._setHierarchicalLink(False)

    # MT_label__
    self.obj28568.MT_label__.setValue('2')

    # MT_pivotOut__
    self.obj28568.MT_pivotOut__.setValue('')
    self.obj28568.MT_pivotOut__.setNone()

    self.obj28568.graphClass_= graph_MT_post__ApplyModel
    if self.genGraphics:
       new_obj = graph_MT_post__ApplyModel(1110.0,419.0,self.obj28568)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28568.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28568)
    self.globalAndLocalPostcondition(self.obj28568, rootNode)
    self.obj28568.postAction( rootNode.CREATE )

    self.obj28569=MT_post__Male_T(self)
    self.obj28569.isGraphObjectVisual = True

    if(hasattr(self.obj28569, '_setHierarchicalLink')):
      self.obj28569._setHierarchicalLink(False)

    # MT_label__
    self.obj28569.MT_label__.setValue('4')

    # MT_pivotOut__
    self.obj28569.MT_pivotOut__.setValue('')
    self.obj28569.MT_pivotOut__.setNone()

    # MT_post__name
    self.obj28569.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj28569.MT_post__name.setHeight(15)

    self.obj28569.graphClass_= graph_MT_post__Male_T
    if self.genGraphics:
       new_obj = graph_MT_post__Male_T(1330.0,479.0,self.obj28569)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__Male_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28569.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28569)
    self.globalAndLocalPostcondition(self.obj28569, rootNode)
    self.obj28569.postAction( rootNode.CREATE )

    self.obj28570=MT_post__Male_S(self)
    self.obj28570.isGraphObjectVisual = True

    if(hasattr(self.obj28570, '_setHierarchicalLink')):
      self.obj28570._setHierarchicalLink(False)

    # MT_label__
    self.obj28570.MT_label__.setValue('3')

    # MT_pivotOut__
    self.obj28570.MT_pivotOut__.setValue('')
    self.obj28570.MT_pivotOut__.setNone()

    # MT_post__name
    self.obj28570.MT_post__name.setValue('\n#===============================================================================\n# You can access the value of the current node\'s attribute value by: attr_value.\n# If the current node shall be created you MUST initialize it here!\n# You can access a node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# Note that the attribute values are those before the match is rewritten.\n# The order in which this code is executed depends on the label value\n# of the encapsulating node.\n# The given action must return the new value of the attribute.\n#===============================================================================\n\nreturn attr_value\n')
    self.obj28570.MT_post__name.setHeight(15)

    self.obj28570.graphClass_= graph_MT_post__Male_S
    if self.genGraphics:
       new_obj = graph_MT_post__Male_S(1330.0,339.0,self.obj28570)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MT_post__Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28570.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28570)
    self.globalAndLocalPostcondition(self.obj28570, rootNode)
    self.obj28570.postAction( rootNode.CREATE )

    self.obj28572=RHS(self)
    self.obj28572.isGraphObjectVisual = True

    if(hasattr(self.obj28572, '_setHierarchicalLink')):
      self.obj28572._setHierarchicalLink(False)

    # action
    self.obj28572.action.setValue('#===============================================================================\n# This code is executed after the rule has been applied.\n# You can access a node labelled n matched by this rule by: PostNode(\'n\').\n# To access attribute x of node n, use: PostNode(\'n\')[\'x\'].\n#===============================================================================\n\npass\n')
    self.obj28572.action.setHeight(15)

    self.obj28572.graphClass_= graph_RHS
    if self.genGraphics:
       new_obj = graph_RHS(990.0,219.0,self.obj28572)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("RHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28572.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28572)
    self.globalAndLocalPostcondition(self.obj28572, rootNode)
    self.obj28572.postAction( rootNode.CREATE )

    self.obj28573=LHS(self)
    self.obj28573.isGraphObjectVisual = True

    if(hasattr(self.obj28573, '_setHierarchicalLink')):
      self.obj28573._setHierarchicalLink(False)

    # constraint
    self.obj28573.constraint.setValue('#===============================================================================\n# This code is executed after the nodes in the LHS have been matched.\n# You can access a matched node labelled n by: PreNode(\'n\').\n# To access attribute x of node n, use: PreNode(\'n\')[\'x\'].\n# The given constraint must evaluate to a boolean expression:\n#    returning True enables the rule to be applied,\n#    returning False forbids the rule from being applied.\n#===============================================================================\n\nreturn True\n')
    self.obj28573.constraint.setHeight(15)

    self.obj28573.graphClass_= graph_LHS
    if self.genGraphics:
       new_obj = graph_LHS(530.0,219.0,self.obj28573)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("LHS", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj28573.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj28573)
    self.globalAndLocalPostcondition(self.obj28573, rootNode)
    self.obj28573.postAction( rootNode.CREATE )

    # Connections for obj28555 (graphObject_: Obj143) of type MT_pre__Male_S
    self.drawConnections(
 )
    # Connections for obj28557 (graphObject_: Obj145) of type MT_pre__MatchModel
    self.drawConnections(
(self.obj28557,self.obj28561,[671.0, 320.0, 771.0, 350.0],"true", 2) )
    # Connections for obj28558 (graphObject_: Obj146) of type MT_pre__ApplyModel
    self.drawConnections(
(self.obj28558,self.obj28562,[675.0, 460.0, 773.0, 490.0],"true", 2) )
    # Connections for obj28559 (graphObject_: Obj147) of type MT_pre__Male_T
    self.drawConnections(
 )
    # Connections for obj28561 (graphObject_: Obj149) of type MT_pre__match_contains
    self.drawConnections(
(self.obj28561,self.obj28555,[771.0, 350.0, 871.0, 380.0],"true", 2) )
    # Connections for obj28562 (graphObject_: Obj150) of type MT_pre__apply_contains
    self.drawConnections(
(self.obj28562,self.obj28559,[773.0, 490.0, 871.0, 520.0],"true", 2) )
    # Connections for obj28564 (graphObject_: Obj152) of type MT_post__match_contains
    self.drawConnections(
(self.obj28564,self.obj28570,[1292.5, 350.0, 1391.0, 380.0],"true", 2) )
    # Connections for obj28565 (graphObject_: Obj153) of type MT_post__MatchModel
    self.drawConnections(
(self.obj28565,self.obj28564,[1194.0, 320.0, 1292.5, 350.0],"true", 2) )
    # Connections for obj28566 (graphObject_: Obj154) of type MT_post__apply_contains
    self.drawConnections(
(self.obj28566,self.obj28569,[1294.5, 490.0, 1391.0, 520.0],"true", 2) )
    # Connections for obj28567 (graphObject_: Obj155) of type MT_post__backward_link
    self.drawConnections(
(self.obj28567,self.obj28570,[1391.0, 450.0, 1391.0, 380.0],"true", 2) )
    # Connections for obj28568 (graphObject_: Obj156) of type MT_post__ApplyModel
    self.drawConnections(
(self.obj28568,self.obj28566,[1198.0, 460.0, 1294.5, 490.0],"true", 2) )
    # Connections for obj28569 (graphObject_: Obj157) of type MT_post__Male_T
    self.drawConnections(
(self.obj28569,self.obj28567,[1391.0, 520.0, 1391.0, 450.0],"true", 2) )
    # Connections for obj28570 (graphObject_: Obj158) of type MT_post__Male_S
    self.drawConnections(
 )
    # Connections for obj28572 (graphObject_: Obj160) of type RHS
    self.drawConnections(
 )
    # Connections for obj28573 (graphObject_: Obj161) of type LHS
    self.drawConnections(
 )

newfunction = build_back_M2M_MDL

loadedMMName = ['MT_pre__SimpleDSLTrans_META', 'MT_post__SimpleDSLTrans_META', 'MoTifRule_META']

atom3version = '0.3'
